home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / freeWAIS-sf-1.1 / ir / ui-local.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-04  |  16.7 KB  |  678 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.
  4.  
  5.    Brewster@think.com
  6. */
  7.  
  8. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  9.  
  10.  
  11. #ifndef lint
  12. static char *RCSid = "$Header: /usr/local/ls6/src+data/src/freeWAIS-sf/ir/RCS/ui-local.c,v 1.4 1994/08/05 07:12:49 pfeifer Exp $";
  13. #endif
  14.  
  15. /* Change log:
  16.  * $Log: ui-local.c,v $
  17.  * Revision 1.4  1994/08/05  07:12:49  pfeifer
  18.  * Release beta 04
  19.  *
  20.  * Revision 1.3  1994/05/20  12:57:50  pfeifer
  21.  * beta
  22.  *
  23.  * Revision 1.2  1994/03/08  21:07:05  pfeifer
  24.  * Patchlevel 04
  25.  *
  26.  * Revision 1.1  1993/02/16  15:05:35  freewais
  27.  * Initial revision
  28.  *
  29.  * Revision 1.16  92/03/18  09:01:09  jonathan
  30.  * don't free DocObjs[0]->Type, it's a copy of the input!
  31.  * 
  32.  * Revision 1.15  92/03/06  12:53:03  jonathan
  33.  * Plug another memory leak.  From ericb@baker.dartmouth.edu (Eric J Bivona).
  34.  * 
  35.  * Revision 1.14  92/02/14  15:26:53  jonathan
  36.  * Conditionalized interpret_message and locally_answer_message so client need
  37.  * not include search engine.
  38.  * 
  39.  * Revision 1.13  92/02/12  13:53:41  jonathan
  40.  * Added "$Log" so RCS will put the log message in the header
  41.  * 
  42.  * 
  43. */
  44.  
  45. /* 
  46.  * this is a simple ui toolkit for building other ui's on top.
  47.  * -brewster
  48.  * 
  49.  * top level functions:
  50.  *   generate_search_apdu
  51.  *   generate_retrieval_apdu
  52.  *   interpret_message
  53.  *
  54.  */
  55.  
  56. /* to do:
  57.  *   generate multiple queries for long documents.
  58.  *     this will crash if the file being retrieved is larger than 100k.
  59.  *   
  60.  */
  61.  
  62. #include "ui.h"
  63. #include "wutil.h"
  64. #include "ustubs.h"
  65. #include "futil.h"
  66.  
  67. #include <ctype.h>
  68. #include <errno.h>
  69. /*
  70. #include <string.h>
  71. */
  72. #include "cdialect.h"
  73. #include <sys/types.h>
  74.  
  75. /* returns a pointer in the buffer of the first free byte.
  76.    if it overflows, then NULL is returned 
  77.  */
  78. char *
  79. generate_search_apdu(buff,
  80.              buff_len,
  81.              seed_words,
  82.              database_name,
  83.              docobjs,
  84.              maxDocsRetrieved)
  85. char* buff;     /* buffer to hold the apdu */
  86. long *buff_len;    /* length of the buffer changed to reflect new data written */
  87. char *seed_words;    /* string of the seed words */
  88. char *database_name;
  89. DocObj** docobjs;
  90. long maxDocsRetrieved;
  91. {
  92.   /* local variables */
  93.  
  94.   SearchAPDU *search3;
  95.   char  *end_ptr;
  96.   static char *database_names[2] = {"", 0};
  97.   any refID;
  98.   WAISSearch *query;
  99.   refID.size = 1;
  100.   refID.bytes = "3";
  101.  
  102.   database_names[0] = database_name;
  103.   query = makeWAISSearch(seed_words,
  104.                          docobjs, /* DocObjsPtr */
  105.                          0L,
  106.                          1L,     /* DateFactor */
  107.                          0L,     /* BeginDateRange */
  108.                          0L,     /* EndDateRange */
  109.                          maxDocsRetrieved
  110.                          );
  111.  
  112.   search3 = makeSearchAPDU(30L, 
  113.                5000L, /* should be large */
  114.                30L,
  115.                            1L,    /* replace indicator */
  116.                            "",    /* result set name */
  117.                            database_names, /* database name */   
  118.                            QT_RelevanceFeedbackQuery, /* query_type */
  119.                            0L,   /* element name */
  120.                            NULL, /* reference ID */
  121.                            query);
  122.  
  123.   end_ptr = writeSearchAPDU(search3, buff, buff_len);
  124.  
  125.   CSTFreeWAISSearch(query);
  126.   freeSearchAPDU(search3);
  127.   return(end_ptr);
  128. }
  129.  
  130.  
  131. /* returns a pointer into the buffer of the next free byte.
  132.    if it overflowed, then NULL is returned
  133.  */
  134.  
  135. char *
  136.  generate_retrieval_apdu(buff,
  137.             buff_len,
  138.             docID,
  139.             chunk_type,
  140.             start,
  141.             end,
  142.             type,
  143.             database_name)
  144. char *buff;
  145. long *buff_len;    /* length of the buffer changed to reflect new data written */
  146. any *docID;
  147. long chunk_type;
  148. long start;
  149. long end;
  150. char *type;
  151. char *database_name;
  152. {
  153.   SearchAPDU *search;
  154.   char  *end_ptr;
  155.  
  156.   static char *database_names[2];
  157.   static char *element_names[3];
  158.   any refID;
  159.  
  160.   DocObj *DocObjs[2];
  161.   any *query;            /* changed from char* by brewster */
  162.  
  163.   if(NULL == type)
  164.     type = s_strdup("TEXT");
  165.  
  166.   database_names[0] = database_name;
  167.   database_names[1] = NULL;
  168.  
  169.   element_names[0] = " ";
  170.   element_names[1] = ES_DocumentText;
  171.   element_names[2] = NULL;
  172.  
  173.   refID.size = 1;
  174.   refID.bytes = "3";
  175.   
  176.   switch(chunk_type){
  177.   case CT_line: 
  178.     DocObjs[0] = makeDocObjUsingLines(docID, type, start, end);
  179.     break;
  180.   case CT_byte:
  181.     DocObjs[0] = makeDocObjUsingBytes(docID, type, start, end);
  182.     break;
  183.   }
  184.   DocObjs[1] = NULL;
  185.  
  186.   query = makeWAISTextQuery(DocObjs);   
  187.   search = makeSearchAPDU( 10L, 16L, 15L, 
  188.               1L,    /* replace indicator */
  189.               "FOO", /* result set name */
  190.               database_names, /* database name */   
  191.               QT_TextRetrievalQuery, /* query_type */
  192.               element_names, /* element name */
  193.               &refID, /* reference ID */
  194.               query);
  195.   end_ptr = writeSearchAPDU(search, buff, buff_len);
  196.   /* s_free(DocObjs[0]->Type); it's a copy of the input, don't free it! */
  197.   CSTFreeDocObj(DocObjs[0]);
  198.   CSTFreeWAISTextQuery(query);
  199.   freeSearchAPDU(search);
  200.   return(end_ptr);
  201. }
  202.  
  203. /* not currently used 
  204.  
  205. static boolean isnumber _AP((char* string));
  206.  
  207. static boolean isnumber(string)
  208. char *string;
  209. {
  210.   long count;
  211.   for(count = 0; count < strlen(string); count++){
  212.     if(!isdigit(string[count])){
  213.       return(false);
  214.     }
  215.   }
  216.   return(true);
  217. }
  218.  
  219. */
  220.  
  221. /* this will negotiate with server, and returs the maximum buffer size 
  222.    the server can handle.
  223.  
  224.    A connection should be established first using open_socket.
  225.  
  226. */
  227.  
  228. long init_connection(inBuffer, outBuffer, bufferSize, connection, userInfo)
  229. char *inBuffer, *outBuffer;
  230. long bufferSize;
  231. FILE *connection;
  232. char *userInfo;
  233. { 
  234.   InitAPDU* init = NULL;
  235.   InitResponseAPDU* reply = NULL;
  236.   long result;
  237.   /* construct an init */
  238.   init = makeInitAPDU(true,false,false,false,false,bufferSize,bufferSize,
  239.               userInfo,defaultImplementationID(),
  240.               defaultImplementationName(),
  241.               defaultImplementationVersion(),NULL,userInfo);
  242.   /* write it to the buffer */
  243.   result = writeInitAPDU(init,inBuffer+HEADER_LENGTH,&bufferSize) - inBuffer;
  244.  
  245.   freeInitAPDU(init);           /* Free also if there is no error(up) */
  246.   if(result < 0){
  247.     return(-1);
  248.   }
  249.   if(0 ==
  250.      interpret_message(inBuffer,
  251.                result - HEADER_LENGTH,
  252.                outBuffer,
  253.                bufferSize,
  254.                connection,
  255.                false    /* true verbose */    
  256.                )) {
  257.     /* error making a connection */
  258.     return (-1);
  259.   }
  260.   if (readInitResponseAPDU(&reply,outBuffer + HEADER_LENGTH) == NULL){
  261.     freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  262.     freeInitResponseAPDU(reply);
  263.     return(-1);
  264.   }
  265.   if (reply->Result == false)
  266.     {                /* the server declined service */
  267.       freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  268.       freeInitResponseAPDU(reply);
  269.       return(-1);
  270.     }
  271.   else                /* we got a response back */
  272.     { result = reply->MaximumRecordSize;
  273.       freeWAISInitResponse((WAISInitResponse*)reply->UserInformationField);
  274.       freeInitResponseAPDU(reply);
  275.       return(result);
  276.     }
  277. }
  278.  
  279. #ifdef LOCAL_SEARCH
  280. /* returns the length of the response, 0 if an error */
  281. long
  282. locally_answer_message(request_message,
  283.                request_length,
  284.                response_message,
  285.                response_buffer_length)
  286. char *request_message;
  287. long request_length;
  288. char *response_message;
  289. long response_buffer_length;
  290. {
  291.   long request_length_internal = request_length;
  292.   long response_length;
  293.   WAISMessage header;
  294.   long maxBufferSize = response_buffer_length;
  295.  
  296.   readWAISPacketHeader(request_message, &header);
  297.   {
  298.     char length_array[11];
  299.     strncpy(length_array, header.msg_len, 10);
  300.     length_array[10] = '\0';
  301.     request_length_internal = atol(length_array);
  302.   }
  303.   /*
  304.     printf("request length is %ld (%ld from caller)\n", 
  305.     request_length_internal,
  306.     request_length);
  307.     */
  308.   
  309.   response_length =
  310.     interpret_buffer(request_message + HEADER_LENGTH, 
  311.              request_length_internal,
  312.              response_message + HEADER_LENGTH,
  313.              response_buffer_length,
  314.              &maxBufferSize,
  315.              (long)header.hdr_vers,
  316.              "");
  317.   if(0 > response_length)
  318.     return(0);
  319.   writeWAISPacketHeader(response_message,
  320.             response_length,
  321.             (long)'z',    /* Z39.50 */
  322.             "DowQuest  ", /* server name */
  323.             (long)NO_COMPRESSION,    /* no compression */
  324.             (long)NO_ENCODING,(long)header.hdr_vers);
  325.   return(response_length);
  326. }
  327. #endif
  328.  
  329. /* this is a safe version of unix 'read' it does all the checking
  330.  * and looping necessary
  331.  * to those trying to modify the transport code to use non-UNIX streams:
  332.  *  This is the function to modify!
  333.  */
  334. long read_from_stream(d,buf,nbytes)
  335. long d;                /* this is the stream */
  336. char *buf;
  337. long nbytes;
  338. {
  339.   long didRead;
  340.   long toRead = nbytes;
  341.   long totalRead = 0;        /* paranoia */
  342.  
  343.   while (toRead > 0){
  344.     didRead = read (d, buf, toRead);
  345.     if(didRead == -1)        /* error*/
  346.       return(-1);
  347.     if(didRead == 0)        /* eof */
  348.       return(-2);        /* maybe this should return 0? */
  349.     toRead -= didRead;
  350.     buf += didRead;
  351.     totalRead += didRead;
  352.   }
  353.   if(totalRead != nbytes)    /* we overread for some reason */
  354.     return(- totalRead);    /* bad news */    
  355.   return(totalRead);
  356. }
  357.  
  358. /* returns the length of the response, 0 if an error */
  359.  
  360. long 
  361. transport_message(connection,
  362.           request_message,
  363.           request_length,
  364.           response_message,
  365.           response_buffer_length)
  366. FILE *connection;
  367. char *request_message;
  368. long request_length;
  369. char *response_message;
  370. long response_buffer_length;
  371. {
  372.   WAISMessage header;
  373.   long response_length;
  374.  
  375.   
  376.   /* Write out message. Read back header. Figure out response length. */
  377.   
  378.   if( request_length + HEADER_LENGTH
  379.      != fwrite (request_message, 1L, request_length + HEADER_LENGTH, connection))
  380.     return 0;
  381.  
  382.   fflush(connection);
  383.  
  384.   /* read for the first '0' */
  385.  
  386.   while(1){
  387.     if(0 > read_from_stream(fileno(connection), response_message, 1))
  388.       return 0;
  389.     if('0' == response_message[0])
  390.       break;
  391.   }
  392.  
  393.   if(0 > read_from_stream(fileno(connection), 
  394.                   response_message + 1, 
  395.                   HEADER_LENGTH - 1))
  396.     return 0;
  397.  
  398.   readWAISPacketHeader(response_message, &header);
  399.   {
  400.     char length_array[11];
  401.     strncpy(length_array, header.msg_len, 10);
  402.     length_array[10] = '\0';
  403.     response_length = atol(length_array);
  404.     /*
  405.       if(verbose){
  406.       printf("WAIS header: '%s' length_array: '%s'\n", 
  407.       response_message, length_array);
  408.       }
  409.       */
  410.     if(response_length > response_buffer_length){
  411.       /* we got a message that is too long, therefore empty the message out,
  412.      and return 0 */
  413.       long i;
  414.       for(i = 0; i < response_length; i++){
  415.     read_from_stream(fileno(connection), 
  416.              response_message + HEADER_LENGTH,
  417.              1);
  418. /*    fread(response_message + HEADER_LENGTH, 1, 1, connection); */
  419.       }
  420.       return(0);
  421.     }
  422.   }
  423.   if(0 > read_from_stream(fileno(connection), 
  424.                   response_message + HEADER_LENGTH,
  425.                   response_length))
  426. /*  if(0 > fread(response_message + HEADER_LENGTH,
  427.            1, response_length, connection)) */
  428.     return 0;
  429.   return(response_length);
  430. }
  431.  
  432.  
  433. /* ------------------------------------------------------------*/
  434.  
  435. /*  Facility to record messages sent and recieved for testing 
  436.     and timing purposes. */
  437.  
  438. /* from c:
  439.  
  440.    putenv(strdup("IR_FILE=/users/menlo-park/brewster/tmp/infile"));
  441.  
  442.    from csh:
  443.  
  444.    setenv IR_FILE /users/menlo-park/brewster/tmp/infile
  445.  
  446.  */
  447.  
  448. boolean environment_variables_read = false; 
  449. char* ir_file_environment_variable = "IR_FILE";
  450. char* ir_file = NULL;
  451.  
  452. void read_environment_variables(host, port)
  453.      char* host;
  454.      char* port;
  455. {
  456.   
  457.   if(!environment_variables_read){
  458.     FILE *stream;
  459.     ir_file = (char*)getenv(ir_file_environment_variable);
  460.     if(ir_file){
  461.       printf("IR_file: %s\n", ir_file);
  462.       stream = fopen(ir_file, "w");
  463.       fprintf(stream, "%s %s\n", host, port);
  464.       fclose(stream);
  465.     }
  466.     environment_variables_read = true;
  467.   }
  468. }
  469.  
  470. /* returns 0 if success */
  471. long write_message_to_file(message, length, filename)
  472.      unsigned char *message;
  473.      long length;
  474.      char*filename;
  475. {
  476.   FILE *stream = fopen(filename, "a");
  477.   if(NULL == stream)
  478.     return(-1);
  479.   
  480.   printf("Writing to file: %s %d characters\n", filename, length);
  481.  
  482.   fprintf(stream, "---------------------------------\n");
  483.   
  484.   if(length != fwrite(message, sizeof(unsigned char), 
  485.               length, stream)){
  486.     perror("fwrite error");
  487.     fclose(stream);
  488.     return(-2);
  489.   }
  490.  
  491.   fprintf(stream, "\n");
  492.  
  493.   if(0 != fclose(stream))
  494.     return(-3);
  495.   return(0);
  496. }  
  497.  
  498. /* ------------------------------------------------------------*/
  499.  
  500. /* returns the number of bytes writeen.  0 if an error */
  501. long
  502. interpret_message(request_message,request_length,
  503.           response_message,
  504.           response_buffer_length,
  505.           connection,
  506.           verbose)
  507. char *request_message;
  508. long request_length; /* length of the buffer */
  509. char *response_message;
  510. long response_buffer_length;
  511. FILE *connection;
  512. boolean verbose;
  513. {
  514.   long response_length;
  515.  
  516.   writeWAISPacketHeader(request_message,
  517.             request_length,
  518.             (long)'z',    /* Z39.50 */
  519.             "wais      ", /* server name */
  520.             (long)NO_COMPRESSION,    /* no compression */
  521.             (long)NO_ENCODING,(long)HEADER_VERSION);
  522.  
  523.   if(ir_file){
  524.     long error_code;
  525.     if(0 != (error_code = 
  526.          write_message_to_file((unsigned char*)request_message, 
  527.                    request_length + HEADER_LENGTH, 
  528.                    ir_file)))
  529.       printf("Error writing log file Code: %d\n", error_code);
  530.   }
  531.     
  532.   if(connection != NULL) {
  533.     if(0 == 
  534.        (response_length =
  535.     transport_message(connection, request_message,
  536.               request_length,
  537.               response_message,
  538.               response_buffer_length)))
  539.       return(0);
  540.   }
  541.   else{
  542. #ifdef LOCAL_SEARCH    
  543.     if(0 == 
  544.        (response_length =
  545.     locally_answer_message(request_message, request_length, 
  546.                    response_message,
  547.                    response_buffer_length)))
  548.       return(0);
  549. #else
  550.     waislog(WLOG_HIGH, WLOG_ERROR, "Local search not supported in this version");
  551.     return(0);
  552. #endif
  553.   }
  554.   if(verbose){
  555.     printf ("decoded %ld bytes: \n", response_length);
  556.     twais_dsply_rsp_apdu(response_message + HEADER_LENGTH, 
  557.              request_length);
  558.   }
  559.   if(ir_file){
  560.     long error_code;
  561.     if(0 != (error_code = 
  562.          write_message_to_file((unsigned char*)response_message, 
  563.                    response_length + HEADER_LENGTH, 
  564.                    ir_file)))
  565.       printf("Error writing log file Code: %d\n", error_code);
  566.   }
  567.   return(response_length);
  568. }
  569.  
  570. /* this closes the connection to the socket.
  571.  * the mythology is that this is cleaner than exiting
  572.  */
  573.  
  574. long close_connection(connection)
  575. FILE *connection;
  576. {
  577.   long result = 0;
  578.   
  579.   if(connection != NULL){
  580.     result = fclose(connection);
  581.   }
  582.   return(result);
  583. }
  584.   
  585. void
  586. display_text_record_completely(record,quote_string_quotes)
  587. WAISDocumentText *record;
  588. boolean quote_string_quotes;
  589. {
  590.   long count;
  591.   /* printf(" Text\n");
  592.      print_any("     DocumentID:  ", record->DocumentID);
  593.      printf("     VersionNumber:  %d\n", record->VersionNumber);
  594.      */
  595.   for(count = 0; count < record->DocumentText->size; count++){
  596.     long ch = (unsigned char)record->DocumentText->bytes[count];
  597.     if(27 == ch){
  598.       /* then we have an escape code */
  599.       /* if the next letter is '(' or ')', then ignore two letters */
  600.       if('(' == record->DocumentText->bytes[count + 1] ||
  601.      ')' == record->DocumentText->bytes[count + 1])
  602.     count += 1;             /* it is a term marker */
  603.       else count += 4;        /* it is a paragraph marker */
  604.     }
  605.     else if (ch == '\t') /* a TAB! */
  606.       putc(ch, stdout);
  607.     else if (isprint(ch)){
  608.       if(quote_string_quotes && ch == '"')
  609.     putc('\\', stdout);
  610.       putc(ch, stdout);
  611.     } 
  612.     else if (ch == '\n' || ch == '\r')
  613.       printf ("\n");
  614.   }
  615. }
  616.  
  617. /* modifies the string to exclude all seeker codes. sets length to
  618.    the new length. */
  619. char *delete_seeker_codes(string,length)
  620. char *string;
  621. long *length;
  622. {
  623.   long original_count; /* index into the original string */
  624.   long new_count = 0; /* index into the collapsed string */
  625.   for(original_count = 0; original_count < *length; original_count++){
  626.     if(27 == string[original_count]){
  627.       /* then we have an escape code */
  628.       /* if the next letter is '(' or ')', then ignore two letters */
  629.       if('(' == string[original_count + 1] ||
  630.     ')' == string[original_count + 1])
  631.      original_count += 1;    /* it is a term marker */
  632.       else original_count += 4; /* it is a paragraph marker */
  633.     }
  634.     else string[new_count++] = string[original_count];
  635.   }
  636.   *length = new_count;
  637.   return(string);
  638. }
  639.  
  640.  
  641.   
  642. /* returns a pointer to a string with good stuff */
  643. char *trim_junk(headline)
  644. char *headline;
  645. {
  646.   long length = strlen(headline) + 1; /* include the trailing null */
  647.   long i,j;
  648.   headline = delete_seeker_codes(headline, &length);
  649.  
  650.  
  651.   /* delete leading spaces */
  652.   for(i=0; i < strlen(headline); i++){
  653.     if(isprint(headline[i])){
  654.       break;
  655.     }
  656.   }
  657.   headline = headline + i;
  658.   /* delete trailing stuff */
  659.   for (i = 0, j = 0; i < strlen(headline)+1; i++) {
  660.     if ((headline[i] != '\r') && (headline[i] != '\n')) {
  661.       headline[j++] = headline[i];
  662.     }
  663.   }
  664.   
  665.  
  666.   for(i=strlen(headline) - 1 ; i > 0; i--){
  667.     if(isprint(headline[i])){
  668.       break;
  669.     }
  670.     headline[i] = '\0';
  671.   }
  672.   
  673.   return(headline);
  674. }
  675.  
  676.  
  677.  
  678.